sHelp
                                     LAB.L.THDR
     i   2
   lab.l.test.header.dictionary
     lab.l.test.hdr.groups
     lab.l.test.hdr.header.cont.lin
     lab.l.test.hdr.header.lines
     lab.l.test.hdr.tests.by.queue
       lab.l.test.hdr.exclude.if.ord
       lab.l.test.hdr.if.ord.tests
       lab.l.test.hdr.include.if.ord
     lab.l.test.hdr.tests.by.value

 Ì     i   2
lab.l.test.header.dictionary    (main) 
[mnemonic]
&SLH[slh]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 mnemonic                    10 FREE     L                 slh                                                         
 active                       1 YN       L                 &SLH[slh]|0                                                 
 header.chain               200 FREE     L                 &SLH[slh]C                                                  
 horiz.vert.or.list           2 CHOICE   L                 &SLH[slh]|3                                                 
 last.update                 50 FREE     L                 &SLH[slh]UPD                                                
 level                        1 PINT     R                 VAL=IF{7^LV,DO{IF{'@LAB.L.THDR.header.chain|LV LV-1'&l      
                                                           VAL=t;0^LV}},LV+1}                                          
 list.map.or.mnemonic        15 CHOICE   L                                                                             
 name                        30 FREE     L                 &SLH[slh]|1                                                 
 new.page                     2 PINT     R                 &SLH[slh]|4                                                 
 parent                      10 FREE     L  LAB.L.THDR     &SLH[slh]|6                                             
 sort.number                  8 PDEC     R                 &SLH[slh]|5                                                 
 spec.result.format          10 FREE     L  LAB.L.RFMT     &SLH[slh]|8                                             
 sum.result.format           10 FREE     L  LAB.L.RFMT     &SLH[slh]|7                                             
 type                         4 CHOICE   L                 &SLH[slh]|2                                                 
 Ì      i   2
lab.l.test.hdr.groups    (groups) 
[mnemonic, group]
&SLH[slh]G[schg]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 group                       10 FREE     L  LAB.C.HDR.GRP  schg                                                    
 Ì      i   2
lab.l.test.hdr.header.cont.lin    (header.cont.lines) 
[mnemonic, hdr.cont.q]
&SLH[slh]HC[slhQC]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 hdr.cont.q                   2 PINT     R                 slhQC                                                       
 fill.cont                    1 FREE.NS  L                 &SLH[slh]HC[slhQC]|2                                        
 header.cont.line            80 FREE.NS  L                 &SLH[slh]HC[slhQC]|0                                        
 justify.cont                 1 CHOICE   L                 &SLH[slh]HC[slhQC]|1                                        
 Ì      i   2
lab.l.test.hdr.header.lines    (header.lines) 
[mnemonic, hdr.q]
&SLH[slh]H[slhQ]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 hdr.q                        2 PINT     R                 slhQ                                                        
 fill                         1 FREE.NS  L                 &SLH[slh]H[slhQ]|2                                          
 header.line                 80 FREE.NS  L                 &SLH[slh]H[slhQ]|0                                          
 justify                      1 CHOICE   L                 &SLH[slh]H[slhQ]|1                                          
 Ì      i   2
lab.l.test.hdr.tests.by.queue    (tests.by.queue) 
[mnemonic, test.q]
&SLH[slh]TQ[slhTQ]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 test.q                       3 PINT     R                 slhTQ                                                       
 allow.dup                    1 YN       L                 &SLH[slh]TQ[slhTQ]|2                                        
 explode                      1 YN       L                 &SLH[slh]TQ[slhTQ]|3                                        
 from.nearest.test           15 FREE     L                 VAL=IF{@LAB.L.TEST.mnemonic[@from.test.number^XX];DO{.      
                                                           VAL=_@LAB.L.TEST.type[XX]'=.P'=.T&XX +@LAB.L.TEST.main      
                                                           VAL=[XX]'>IF{@thru.test.number;@Z.del}^XX},@LAB.L.T      
                                                           VAL=EST.mnemonic[XX]}                                       
 from.test.number             9 PDEC5    R                 &SLH[slh]TQ[slhTQ]|0                                        
 thru.nearest.test           15 FREE     L                 VAL=IF{@LAB.L.TEST.mnemonic[@thru.test.number^XX];DO{.      
                                                           VAL=_@LAB.L.TEST.type[XX]'=.P'=.T&XX -@LAB.L.TEST.main      
                                                           VAL=[XX]'<@from.test.number^XX},@LAB.L.TEST.mnemoni      
                                                           VAL=c[XX]}                                                  
 thru.test.number             9 PDEC5    R                 &SLH[slh]TQ[slhTQ]|1                                        
 Ì      i   2
lab.l.test.hdr.exclude.if.ord    (excl.if.ord.tests) 
[mnemonic,test.q, excl.if.ord.test]
&SLH[slh]TQ[slhTQ]OE[slt]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 excl.if.ord.test             9 PDEC5    R  LAB.L.TEST     slt                                                     
 excl.if.ord                  1 YN       L                 &SLH[slh]TQ[slhTQ]OE[slt]|0                                 
 Ì      i   2
lab.l.test.hdr.if.ord.tests    (if.ord.tests) 
[mnemonic,test.q, if.ord.test]
&SLH[slh]TQ[slhTQ]IO[slt]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 if.ord.test                  9 PDEC5    R  LAB.L.TEST     slt                                                     
 if.ord.test.action           7 CHOICE   L                 &SLH[slh]TQ[slhTQ]IO[slt]|0                                 
 Ì      i   2
lab.l.test.hdr.include.if.ord    (incl.if.ord.tests) 
[mnemonic,test.q, incl.if.ord.test]
&SLH[slh]TQ[slhTQ]OI[slt]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 incl.if.ord.test             9 PDEC5    R  LAB.L.TEST     slt                                                     
 incl.if.ord                  1 YN       L                 &SLH[slh]TQ[slhTQ]OI[slt]|0                                 
 Ì      i   2
lab.l.test.hdr.tests.by.value    (tests.by.value) 
[mnemonic, test]
&SLH[slh]TV[slt]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 test                         9 PDEC5    R  LAB.L.TEST     slt                                                     
 test.allow.dup               1 YN       L                 &SLH[slh]TV[slt]|1                                          
 test.val.q                   3 PINT     R                 &SLH[slh]TV[slt]|0                                          
 Ì       2
 INDEX FILE/INTERNAL NAME           SUBSCRIPTS/PHYSICAL BASE

 lab.l.test.hdr.act.test.x          [group,test,mnemonic]
   act.test.x                         &SLHB[schg,slt,slh]

 lab.l.test.hdr.fr.th.test.x        [from.test.number,thru.test.number,mnemonic] = test.q
   from.thru.test.x                   &SLHF[slt1,slt2,slh]

 lab.l.test.hdr.group.x             [group,mnemonic]
   group.x                            &SLHG[schg,slh]

 lab.l.test.hdr.if.ord.test.x       [if.ord.test,mnemonic,test.q]
   if.ord.test.x                      &SLHIO[slt,slh,slhTQ]

 lab.l.test.hdr.parent.index        [parent,mnemonic]
   parent.x                           &SLHP[slhP,slh]

 lab.l.test.hdr.sort.number.x       [sort.number] = mnemonic
   sort.x                             &SLHN[slhN]

 lab.l.test.hdr.sum.test.x          [group,test,mnemonic]
   sum.test.x                         &SLHT[schg,slt,slh]